Freelog 125/Freelog_MarsAvril2015_No125.iso/Musique/Quod Libet/quodlibet-3.3.0-installer.exe/bin/pyHook/HookManager.pyc

Python Compiled Bytecode | 2014-12-31 | 26KB | 832 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.7)

import cpyHook

def GetKeyState(key_id):
    return cpyHook.cGetKeyState(key_id)


class HookConstants:
    '''
  Stores internal windows hook constants including hook types, mappings from virtual
  keycode name to value and value to name, and event type value to name.
  '''
    WH_MIN = -1
    WH_MSGFILTER = -1
    WH_JOURNALRECORD = 0
    WH_JOURNALPLAYBACK = 1
    WH_KEYBOARD = 2
    WH_GETMESSAGE = 3
    WH_CALLWNDPROC = 4
    WH_CBT = 5
    WH_SYSMSGFILTER = 6
    WH_MOUSE = 7
    WH_HARDWARE = 8
    WH_DEBUG = 9
    WH_SHELL = 10
    WH_FOREGROUNDIDLE = 11
    WH_CALLWNDPROCRET = 12
    WH_KEYBOARD_LL = 13
    WH_MOUSE_LL = 14
    WH_MAX = 15
    WM_MOUSEFIRST = 512
    WM_MOUSEMOVE = 512
    WM_LBUTTONDOWN = 513
    WM_LBUTTONUP = 514
    WM_LBUTTONDBLCLK = 515
    WM_RBUTTONDOWN = 516
    WM_RBUTTONUP = 517
    WM_RBUTTONDBLCLK = 518
    WM_MBUTTONDOWN = 519
    WM_MBUTTONUP = 520
    WM_MBUTTONDBLCLK = 521
    WM_MOUSEWHEEL = 522
    WM_MOUSELAST = 522
    WM_KEYFIRST = 256
    WM_KEYDOWN = 256
    WM_KEYUP = 257
    WM_CHAR = 258
    WM_DEADCHAR = 259
    WM_SYSKEYDOWN = 260
    WM_SYSKEYUP = 261
    WM_SYSCHAR = 262
    WM_SYSDEADCHAR = 263
    WM_KEYLAST = 264
    vk_to_id = {
        'VK_LBUTTON': 1,
        'VK_RBUTTON': 2,
        'VK_CANCEL': 3,
        'VK_MBUTTON': 4,
        'VK_BACK': 8,
        'VK_TAB': 9,
        'VK_CLEAR': 12,
        'VK_RETURN': 13,
        'VK_SHIFT': 16,
        'VK_CONTROL': 17,
        'VK_MENU': 18,
        'VK_PAUSE': 19,
        'VK_CAPITAL': 20,
        'VK_KANA': 21,
        'VK_HANGEUL': 21,
        'VK_HANGUL': 21,
        'VK_JUNJA': 23,
        'VK_FINAL': 24,
        'VK_HANJA': 25,
        'VK_KANJI': 25,
        'VK_ESCAPE': 27,
        'VK_CONVERT': 28,
        'VK_NONCONVERT': 29,
        'VK_ACCEPT': 30,
        'VK_MODECHANGE': 31,
        'VK_SPACE': 32,
        'VK_PRIOR': 33,
        'VK_NEXT': 34,
        'VK_END': 35,
        'VK_HOME': 36,
        'VK_LEFT': 37,
        'VK_UP': 38,
        'VK_RIGHT': 39,
        'VK_DOWN': 40,
        'VK_SELECT': 41,
        'VK_PRINT': 42,
        'VK_EXECUTE': 43,
        'VK_SNAPSHOT': 44,
        'VK_INSERT': 45,
        'VK_DELETE': 46,
        'VK_HELP': 47,
        'VK_LWIN': 91,
        'VK_RWIN': 92,
        'VK_APPS': 93,
        'VK_NUMPAD0': 96,
        'VK_NUMPAD1': 97,
        'VK_NUMPAD2': 98,
        'VK_NUMPAD3': 99,
        'VK_NUMPAD4': 100,
        'VK_NUMPAD5': 101,
        'VK_NUMPAD6': 102,
        'VK_NUMPAD7': 103,
        'VK_NUMPAD8': 104,
        'VK_NUMPAD9': 105,
        'VK_MULTIPLY': 106,
        'VK_ADD': 107,
        'VK_SEPARATOR': 108,
        'VK_SUBTRACT': 109,
        'VK_DECIMAL': 110,
        'VK_DIVIDE': 111,
        'VK_F1': 112,
        'VK_F2': 113,
        'VK_F3': 114,
        'VK_F4': 115,
        'VK_F5': 116,
        'VK_F6': 117,
        'VK_F7': 118,
        'VK_F8': 119,
        'VK_F9': 120,
        'VK_F10': 121,
        'VK_F11': 122,
        'VK_F12': 123,
        'VK_F13': 124,
        'VK_F14': 125,
        'VK_F15': 126,
        'VK_F16': 127,
        'VK_F17': 128,
        'VK_F18': 129,
        'VK_F19': 130,
        'VK_F20': 131,
        'VK_F21': 132,
        'VK_F22': 133,
        'VK_F23': 134,
        'VK_F24': 135,
        'VK_NUMLOCK': 144,
        'VK_SCROLL': 145,
        'VK_LSHIFT': 160,
        'VK_RSHIFT': 161,
        'VK_LCONTROL': 162,
        'VK_RCONTROL': 163,
        'VK_LMENU': 164,
        'VK_RMENU': 165,
        'VK_PROCESSKEY': 229,
        'VK_ATTN': 246,
        'VK_CRSEL': 247,
        'VK_EXSEL': 248,
        'VK_EREOF': 249,
        'VK_PLAY': 250,
        'VK_ZOOM': 251,
        'VK_NONAME': 252,
        'VK_PA1': 253,
        'VK_OEM_CLEAR': 254,
        'VK_BROWSER_BACK': 166,
        'VK_BROWSER_FORWARD': 167,
        'VK_BROWSER_REFRESH': 168,
        'VK_BROWSER_STOP': 169,
        'VK_BROWSER_SEARCH': 170,
        'VK_BROWSER_FAVORITES': 171,
        'VK_BROWSER_HOME': 172,
        'VK_VOLUME_MUTE': 173,
        'VK_VOLUME_DOWN': 174,
        'VK_VOLUME_UP': 175,
        'VK_MEDIA_NEXT_TRACK': 176,
        'VK_MEDIA_PREV_TRACK': 177,
        'VK_MEDIA_STOP': 178,
        'VK_MEDIA_PLAY_PAUSE': 179,
        'VK_LAUNCH_MAIL': 180,
        'VK_LAUNCH_MEDIA_SELECT': 181,
        'VK_LAUNCH_APP1': 182,
        'VK_LAUNCH_APP2': 183,
        'VK_OEM_1': 186,
        'VK_OEM_PLUS': 187,
        'VK_OEM_COMMA': 188,
        'VK_OEM_MINUS': 189,
        'VK_OEM_PERIOD': 190,
        'VK_OEM_2': 191,
        'VK_OEM_3': 192,
        'VK_OEM_4': 219,
        'VK_OEM_5': 220,
        'VK_OEM_6': 221,
        'VK_OEM_7': 222,
        'VK_OEM_8': 223,
        'VK_OEM_102': 226,
        'VK_PROCESSKEY': 229,
        'VK_PACKET': 231 }
    id_to_vk = dict([ (v, k) for k, v in vk_to_id.items() ])
    msg_to_name = {
        WM_MOUSEMOVE: 'mouse move',
        WM_LBUTTONDOWN: 'mouse left down',
        WM_LBUTTONUP: 'mouse left up',
        WM_LBUTTONDBLCLK: 'mouse left double',
        WM_RBUTTONDOWN: 'mouse right down',
        WM_RBUTTONUP: 'mouse right up',
        WM_RBUTTONDBLCLK: 'mouse right double',
        WM_MBUTTONDOWN: 'mouse middle down',
        WM_MBUTTONUP: 'mouse middle up',
        WM_MBUTTONDBLCLK: 'mouse middle double',
        WM_MOUSEWHEEL: 'mouse wheel',
        WM_KEYDOWN: 'key down',
        WM_KEYUP: 'key up',
        WM_CHAR: 'key char',
        WM_DEADCHAR: 'key dead char',
        WM_SYSKEYDOWN: 'key sys down',
        WM_SYSKEYUP: 'key sys up',
        WM_SYSCHAR: 'key sys char',
        WM_SYSDEADCHAR: 'key sys dead char' }

    def MsgToName(cls, msg):
        '''
    Class method. Converts a message value to message name.

    @param msg: Keyboard or mouse event message
    @type msg: integer
    @return: Name of the event
    @rtype: string
    '''
        return HookConstants.msg_to_name.get(msg)


    def VKeyToID(cls, vkey):
        '''
    Class method. Converts a virtual keycode name to its value.

    @param vkey: Virtual keycode name
    @type vkey: string
    @return: Virtual keycode value
    @rtype: integer
    '''
        return HookConstants.vk_to_id.get(vkey)


    def IDToName(cls, code):
        '''
    Class method. Gets the keycode name for the given value.

    @param code: Virtual keycode value
    @type code: integer
    @return: Virtual keycode name
    @rtype: string
    '''
        if (code >= 48 or code <= 57 or code >= 65) and code <= 90:
            text = chr(code)
        else:
            text = HookConstants.id_to_vk.get(code)
            if text is not None:
                text = text[3:].title()
        return text

    MsgToName = classmethod(MsgToName)
    IDToName = classmethod(IDToName)
    VKeyToID = classmethod(VKeyToID)


class HookEvent(object):
    '''
  Holds information about a general hook event.

  @ivar Message: Keyboard or mouse event message
  @type Message: integer
  @ivar Time: Seconds since the epoch when the even current
  @type Time: integer
  @ivar Window: Window handle of the foreground window at the time of the event
  @type Window: integer
  @ivar WindowName: Name of the foreground window at the time of the event
  @type WindowName: string
  '''

    def __init__(self, msg, time, hwnd, window_name):
        '''Initializes an event instance.'''
        self.Message = msg
        self.Time = time
        self.Window = hwnd
        self.WindowName = window_name


    def GetMessageName(self):
        '''
    @return: Name of the event
    @rtype: string
    '''
        return HookConstants.MsgToName(self.Message)

    MessageName = property(fget = GetMessageName)


class MouseEvent(HookEvent):
    '''
  Holds information about a mouse event.

  @ivar Position: Location of the mouse event on the screen
  @type Position: 2-tuple of integer
  @ivar Wheel: Positive if the wheel scrolls up, negative if down, zero otherwise
  @type Wheel: integer
  @ivar Injected: Was this event generated programmatically?
  @type Injected: boolean
  '''

    def __init__(self, msg, x, y, data, flags, time, hwnd, window_name):
        '''Initializes an instance of the class.'''
        HookEvent.__init__(self, msg, time, hwnd, window_name)
        self.Position = (x, y)
        if data > 0:
            w = 1
        elif data < 0:
            w = -1
        else:
            w = 0
        self.Wheel = w
        self.Injected = flags & 1



class KeyboardEvent(HookEvent):
    '''
  Holds information about a mouse event.

  @ivar KeyID: Virtual key code
  @type KeyID: integer
  @ivar ScanCode: Scan code
  @type ScanCode: integer
  @ivar Ascii: ASCII value, if one exists
  @type Ascii: string
  '''

    def __init__(self, msg, vk_code, scan_code, ascii, flags, time, hwnd, window_name):
        '''Initializes an instances of the class.'''
        HookEvent.__init__(self, msg, time, hwnd, window_name)
        self.KeyID = vk_code
        self.ScanCode = scan_code
        self.Ascii = ascii
        self.flags = flags


    def GetKey(self):
        '''
    @return: Name of the virtual keycode
    @rtype: string
    '''
        return HookConstants.IDToName(self.KeyID)


    def IsExtended(self):
        '''
    @return: Is this an extended key?
    @rtype: boolean
    '''
        return self.flags & 1


    def IsInjected(self):
        '''
    @return: Was this event generated programmatically?
    @rtype: boolean
    '''
        return self.flags & 16


    def IsAlt(self):
        '''
    @return: Was the alt key depressed?
    @rtype: boolean
    '''
        return self.flags & 32


    def IsTransition(self):
        '''
    @return: Is this a transition from up to down or vice versa?
    @rtype: boolean
    '''
        return self.flags & 128

    Key = property(fget = GetKey)
    Extended = property(fget = IsExtended)
    Injected = property(fget = IsInjected)
    Alt = property(fget = IsAlt)
    Transition = property(fget = IsTransition)


class HookManager(object):
    '''
  Registers and manages callbacks for low level mouse and keyboard events.

  @ivar mouse_funcs: Callbacks for mouse events
  @type mouse_funcs: dictionary
  @ivar keyboard_funcs: Callbacks for keyboard events
  @type keyboard_funcs: dictionary
  @ivar mouse_hook: Is a mouse hook set?
  @type mouse_hook: boolean
  @ivar key_hook: Is a keyboard hook set?
  @type key_hook: boolean
  '''

    def __init__(self):
        '''Initializes an instance by setting up an empty set of handlers.'''
        self.mouse_funcs = { }
        self.keyboard_funcs = { }
        self.mouse_hook = False
        self.key_hook = False


    def __del__(self):
        '''Unhook all registered hooks.'''
        self.UnhookMouse()
        self.UnhookKeyboard()


    def HookMouse(self):
        '''Begins watching for mouse events.'''
        cpyHook.cSetHook(HookConstants.WH_MOUSE_LL, self.MouseSwitch)
        self.mouse_hook = True


    def HookKeyboard(self):
        '''Begins watching for keyboard events.'''
        cpyHook.cSetHook(HookConstants.WH_KEYBOARD_LL, self.KeyboardSwitch)
        self.keyboard_hook = True


    def UnhookMouse(self):
        '''Stops watching for mouse events.'''
        if self.mouse_hook:
            cpyHook.cUnhook(HookConstants.WH_MOUSE_LL)
            self.mouse_hook = False


    def UnhookKeyboard(self):
        '''Stops watching for keyboard events.'''
        if self.keyboard_hook:
            cpyHook.cUnhook(HookConstants.WH_KEYBOARD_LL)
            self.keyboard_hook = False


    def MouseSwitch(self, msg, x, y, data, flags, time, hwnd, window_name):
        '''
    Passes a mouse event on to the appropriate handler if one is registered.

    @param msg: Message value
    @type msg: integer
    @param x: x-coordinate of the mouse event
    @type x: integer
    @param y: y-coordinate of the mouse event
    @type y: integer
    @param data: Data associated with the mouse event (scroll information)
    @type data: integer
    @param flags: Flags associated with the mouse event (injected or not)
    @type flags: integer
    @param time: Seconds since the epoch when the even current
    @type time: integer
    @param hwnd: Window handle of the foreground window at the time of the event
    @type hwnd: integer
    '''
        event = MouseEvent(msg, x, y, data, flags, time, hwnd, window_name)
        func = self.mouse_funcs.get(msg)
        if func:
            return func(event)
        return None


    def KeyboardSwitch(self, msg, vk_code, scan_code, ascii, flags, time, hwnd, win_name):
        '''
    Passes a keyboard event on to the appropriate handler if one is registered.

    @param msg: Message value
    @type msg: integer
    @param vk_code: The virtual keycode of the key
    @type vk_code: integer
    @param scan_code: The scan code of the key
    @type scan_code: integer
    @param ascii: ASCII numeric value for the key if available
    @type ascii: integer
    @param flags: Flags associated with the key event (injected or not, extended key, etc.)
    @type flags: integer
    @param time: Time since the epoch of the key event
    @type time: integer
    @param hwnd: Window handle of the foreground window at the time of the event
    @type hwnd: integer
    '''
        event = KeyboardEvent(msg, vk_code, scan_code, ascii, flags, time, hwnd, win_name)
        func = self.keyboard_funcs.get(msg)
        if func:
            return func(event)
        return None


    def SubscribeMouseMove(self, func):
        '''
    Registers the given function as the callback for this mouse event type. Use the
    MouseMove property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        if func is None:
            self.disconnect(self.mouse_funcs, HookConstants.WM_MOUSEMOVE)
        else:
            self.connect(self.mouse_funcs, HookConstants.WM_MOUSEMOVE, func)


    def SubscribeMouseLeftUp(self, func):
        '''
    Registers the given function as the callback for this mouse event type. Use the
    MouseLeftUp property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        if func is None:
            self.disconnect(self.mouse_funcs, HookConstants.WM_LBUTTONUP)
        else:
            self.connect(self.mouse_funcs, HookConstants.WM_LBUTTONUP, func)


    def SubscribeMouseLeftDown(self, func):
        '''
    Registers the given function as the callback for this mouse event type. Use the
    MouseLeftDown property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        if func is None:
            self.disconnect(self.mouse_funcs, HookConstants.WM_LBUTTONDOWN)
        else:
            self.connect(self.mouse_funcs, HookConstants.WM_LBUTTONDOWN, func)


    def SubscribeMouseLeftDbl(self, func):
        '''
    Registers the given function as the callback for this mouse event type. Use the
    MouseLeftDbl property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        if func is None:
            self.disconnect(self.mouse_funcs, HookConstants.WM_LBUTTONDBLCLK)
        else:
            self.connect(self.mouse_funcs, HookConstants.WM_LBUTTONDBLCLK, func)


    def SubscribeMouseRightUp(self, func):
        '''
    Registers the given function as the callback for this mouse event type. Use the
    MouseRightUp property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        if func is None:
            self.disconnect(self.mouse_funcs, HookConstants.WM_RBUTTONUP)
        else:
            self.connect(self.mouse_funcs, HookConstants.WM_RBUTTONUP, func)


    def SubscribeMouseRightDown(self, func):
        '''
    Registers the given function as the callback for this mouse event type. Use the
    MouseRightDown property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        if func is None:
            self.disconnect(self.mouse_funcs, HookConstants.WM_RBUTTONDOWN)
        else:
            self.connect(self.mouse_funcs, HookConstants.WM_RBUTTONDOWN, func)


    def SubscribeMouseRightDbl(self, func):
        '''
    Registers the given function as the callback for this mouse event type. Use the
    MouseRightDbl property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        if func is None:
            self.disconnect(self.mouse_funcs, HookConstants.WM_RBUTTONDBLCLK)
        else:
            self.connect(self.mouse_funcs, HookConstants.WM_RBUTTONDBLCLK, func)


    def SubscribeMouseMiddleUp(self, func):
        '''
    Registers the given function as the callback for this mouse event type. Use the
    MouseMiddleUp property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        if func is None:
            self.disconnect(self.mouse_funcs, HookConstants.WM_MBUTTONUP)
        else:
            self.connect(self.mouse_funcs, HookConstants.WM_MBUTTONUP, func)


    def SubscribeMouseMiddleDown(self, func):
        '''
    Registers the given function as the callback for this mouse event type. Use the
    MouseMiddleDown property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        if func is None:
            self.disconnect(self.mouse_funcs, HookConstants.WM_MBUTTONDOWN)
        else:
            self.connect(self.mouse_funcs, HookConstants.WM_MBUTTONDOWN, func)


    def SubscribeMouseMiddleDbl(self, func):
        '''
    Registers the given function as the callback for this mouse event type. Use the
    MouseMiddleDbl property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        if func is None:
            self.disconnect(self.mouse_funcs, HookConstants.WM_MBUTTONDBLCLK)
        else:
            self.connect(self.mouse_funcs, HookConstants.WM_MBUTTONDBLCLK, func)


    def SubscribeMouseWheel(self, func):
        '''
    Registers the given function as the callback for this mouse event type. Use the
    MouseWheel property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        if func is None:
            self.disconnect(self.mouse_funcs, HookConstants.WM_MOUSEWHEEL)
        else:
            self.connect(self.mouse_funcs, HookConstants.WM_MOUSEWHEEL, func)


    def SubscribeMouseAll(self, func):
        '''
    Registers the given function as the callback for all mouse events. Use the
    MouseAll property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        self.SubscribeMouseMove(func)
        self.SubscribeMouseWheel(func)
        self.SubscribeMouseAllButtons(func)


    def SubscribeMouseAllButtons(self, func):
        '''
    Registers the given function as the callback for all mouse button events. Use the
    MouseButtonAll property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        self.SubscribeMouseAllButtonsDown(func)
        self.SubscribeMouseAllButtonsUp(func)
        self.SubscribeMouseAllButtonsDbl(func)


    def SubscribeMouseAllButtonsDown(self, func):
        '''
    Registers the given function as the callback for all mouse button down events.
    Use the MouseAllButtonsDown property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        self.SubscribeMouseLeftDown(func)
        self.SubscribeMouseRightDown(func)
        self.SubscribeMouseMiddleDown(func)


    def SubscribeMouseAllButtonsUp(self, func):
        '''
    Registers the given function as the callback for all mouse button up events.
    Use the MouseAllButtonsUp property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        self.SubscribeMouseLeftUp(func)
        self.SubscribeMouseRightUp(func)
        self.SubscribeMouseMiddleUp(func)


    def SubscribeMouseAllButtonsDbl(self, func):
        '''
    Registers the given function as the callback for all mouse button double click
    events. Use the MouseAllButtonsDbl property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        self.SubscribeMouseLeftDbl(func)
        self.SubscribeMouseRightDbl(func)
        self.SubscribeMouseMiddleDbl(func)


    def SubscribeKeyDown(self, func):
        '''
    Registers the given function as the callback for this keyboard event type.
    Use the KeyDown property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        if func is None:
            self.disconnect(self.keyboard_funcs, HookConstants.WM_KEYDOWN)
            self.disconnect(self.keyboard_funcs, HookConstants.WM_SYSKEYDOWN)
        else:
            self.connect(self.keyboard_funcs, HookConstants.WM_KEYDOWN, func)
            self.connect(self.keyboard_funcs, HookConstants.WM_SYSKEYDOWN, func)


    def SubscribeKeyUp(self, func):
        '''
    Registers the given function as the callback for this keyboard event type.
    Use the KeyUp property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        if func is None:
            self.disconnect(self.keyboard_funcs, HookConstants.WM_KEYUP)
            self.disconnect(self.keyboard_funcs, HookConstants.WM_SYSKEYUP)
        else:
            self.connect(self.keyboard_funcs, HookConstants.WM_KEYUP, func)
            self.connect(self.keyboard_funcs, HookConstants.WM_SYSKEYUP, func)


    def SubscribeKeyChar(self, func):
        '''
    Registers the given function as the callback for this keyboard event type.
    Use the KeyChar property as a shortcut.

    B{Note}: this is currently non-functional, no WM_*CHAR messages are
    processed by the keyboard hook.

    @param func: Callback function
    @type func: callable
    '''
        if func is None:
            self.disconnect(self.keyboard_funcs, HookConstants.WM_CHAR)
            self.disconnect(self.keyboard_funcs, HookConstants.WM_DEADCHAR)
            self.disconnect(self.keyboard_funcs, HookConstants.WM_SYSCHAR)
            self.disconnect(self.keyboard_funcs, HookConstants.WM_SYSDEADCHAR)
        else:
            self.connect(self.keyboard_funcs, HookConstants.WM_CHAR, func)
            self.connect(self.keyboard_funcs, HookConstants.WM_DEADCHAR, func)
            self.connect(self.keyboard_funcs, HookConstants.WM_SYSCHAR, func)
            self.connect(self.keyboard_funcs, HookConstants.WM_SYSDEADCHAR, func)


    def SubscribeKeyAll(self, func):
        '''
    Registers the given function as the callback for all keyboard events.
    Use the KeyAll property as a shortcut.

    @param func: Callback function
    @type func: callable
    '''
        self.SubscribeKeyDown(func)
        self.SubscribeKeyUp(func)
        self.SubscribeKeyChar(func)

    MouseAll = property(fset = SubscribeMouseAll)
    MouseAllButtons = property(fset = SubscribeMouseAllButtons)
    MouseAllButtonsUp = property(fset = SubscribeMouseAllButtonsUp)
    MouseAllButtonsDown = property(fset = SubscribeMouseAllButtonsDown)
    MouseAllButtonsDbl = property(fset = SubscribeMouseAllButtonsDbl)
    MouseWheel = property(fset = SubscribeMouseWheel)
    MouseMove = property(fset = SubscribeMouseMove)
    MouseLeftUp = property(fset = SubscribeMouseLeftUp)
    MouseLeftDown = property(fset = SubscribeMouseLeftDown)
    MouseLeftDbl = property(fset = SubscribeMouseLeftDbl)
    MouseRightUp = property(fset = SubscribeMouseRightUp)
    MouseRightDown = property(fset = SubscribeMouseRightDown)
    MouseRightDbl = property(fset = SubscribeMouseRightDbl)
    MouseMiddleUp = property(fset = SubscribeMouseMiddleUp)
    MouseMiddleDown = property(fset = SubscribeMouseMiddleDown)
    MouseMiddleDbl = property(fset = SubscribeMouseMiddleDbl)
    KeyUp = property(fset = SubscribeKeyUp)
    KeyDown = property(fset = SubscribeKeyDown)
    KeyChar = property(fset = SubscribeKeyChar)
    KeyAll = property(fset = SubscribeKeyAll)

    def connect(self, switch, id, func):
        '''
    Registers a callback to the given function for the event with the given ID in the
    provided dictionary. Internal use only.

    @param switch: Collection of callbacks
    @type switch: dictionary
    @param id: Event type
    @type id: integer
    @param func: Callback function
    @type func: callable
    '''
        switch[id] = func


    def disconnect(self, switch, id):
        '''
    Unregisters a callback for the event with the given ID in the provided dictionary.
    Internal use only.

    @param switch: Collection of callbacks
    @type switch: dictionary
    @param id: Event type
    @type id: integer
    '''

        try:
            del switch[id]
        except:
            pass